import axios from '../index'

/**
 * Group Tab API管理器
 * 处理分组和设备相关的API调用
 */
class GroupManager {
    constructor() {
        this.baseUrl = '/groups'
    }

    // ==================== 分组树管理 ====================//
    
    /**
     * 导入设备
     * @param {string} params - 设备文件路径
     * @returns {Promise} API响应
     */
    async importDevice(params = {}) {
        console.log('🔍 [GroupManager] 导入设备', { params })
        try {
            const response = await axios.post(`${this.baseUrl}/import`, { params })
            console.log('✅ [GroupManager] 导入设备成功', { params, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 导入设备失败:', error)
            throw error
        }
    }

    /**
     * 导出设备
     * @param {string} params - 设备数据
     * @returns {Promise} API响应
     */
    async exportDevice(params = {}) {
        console.log('🔍 [GroupManager] 导出设备', { params })
        try {
            const response = await axios.post(`${this.baseUrl}/export`, { params })
            console.log('✅ [GroupManager] 导出设备成功', { params, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 导出设备失败:', error)
            throw error
        }
    }

    /**
     * 获取完整分组树（包含设备）
     * @param {Object} params - 查询参数
     * @returns {Promise} API响应
     */
    async getTreeWithDevices(params = {}) {
        console.log('🔍 [GroupManager] 获取完整分组树', { params })
        try {
            const response = await axios.get(`${this.baseUrl}/tree/all`, { params })
            console.log('✅ [GroupManager] 获取完整分组树成功', { response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 获取完整分组树失败:', error)
            throw error
        }
    }

    /**
     * 获取分组树（仅分组结构）
     * @param {Object} params - 查询参数
     * @returns {Promise} API响应
     */
    async getTree(params = {}) {
        console.log('🔍 [GroupManager] 获取分组树', { params })
        try {
            const response = await axios.get(`${this.baseUrl}/tree`, { params })
            console.log('✅ [GroupManager] 获取分组树成功', { response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 获取分组树失败:', error)
            throw error
        }
    }

    /**
     * 获取单个分组信息
     * @param {string|number} id - 分组ID
     * @returns {Promise} API响应
     */
    async getGroupById(id) {
        console.log('🔍 [GroupManager] 获取分组信息', { id })
        try {
            const response = await axios.get(`${this.baseUrl}/${id}`)
            console.log('✅ [GroupManager] 获取分组信息成功', { id, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 获取分组信息失败:', error)
            throw error
        }
    }

    /**
     * 创建分组
     * @param {Object} data - 分组数据
     * @returns {Promise} API响应
     */
    async createGroup(data) {
        console.log('🔍 [GroupManager] 创建分组', { data })
        try {
            const response = await axios.post(`${this.baseUrl}`, data)
            console.log('✅ [GroupManager] 创建分组成功', { data, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 创建分组失败:', error)
            throw error
        }
    }

    /**
     * 更新分组
     * @param {string|number} id - 分组ID
     * @param {Object|string} data - 分组数据或分组名称
     * @returns {Promise} API响应
     */
    async updateGroup(id, data) {
        console.log('🔍 [GroupManager] 更新分组', { id, data })
        try {
            // 如果传入的是字符串，转换为对象格式
            const requestData = typeof data === 'string' ? { title: data } : data
            const response = await axios.put(`${this.baseUrl}/${id}`, requestData)
            console.log('✅ [GroupManager] 更新分组成功', { id, data, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 更新分组失败:', error)
            throw error
        }
    }

    /**
     * 删除分组
     * @param {string|number} id - 分组ID
     * @returns {Promise} API响应
     */
    async deleteGroup(id) {
        console.log('🔍 [GroupManager] 删除分组', { id })
        try {
            const response = await axios.delete(`${this.baseUrl}/${id}`)
            console.log('✅ [GroupManager] 删除分组成功', { id, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 删除分组失败:', error)
            throw error
        }
    }

    // ==================== 设备管理 ====================//

    /**
     * 获取分组下的设备列表
     * @param {string|number} groupId - 分组ID
     * @param {Object} params - 查询参数
     * @returns {Promise} API响应
     */
    async getDevicesByGroup(groupId, params = {}) {
        console.log('🔍 [GroupManager] 获取分组设备列表', { groupId, params })
        try {
            const response = await axios.get(`${this.baseUrl}/${groupId}/devices`, { params })
            console.log('✅ [GroupManager] 获取分组设备列表成功', { groupId, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 获取分组设备列表失败:', error)
            throw error
        }
    }

    /**
     * 添加设备到分组
     * @param {string|number} groupId - 分组ID
     * @param {Object} deviceData - 设备数据
     * @returns {Promise} API响应
     */
    async addDeviceToGroup(groupId, deviceData) {
        console.log('🔍 [GroupManager] 添加设备到分组', { groupId, deviceData })
        try {
            const response = await axios.post(`${this.baseUrl}/${groupId}/devices`, deviceData)
            console.log('✅ [GroupManager] 添加设备到分组成功', { groupId, deviceData, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 添加设备到分组失败:', error)
            throw error
        }
    }

    /**
     * 更新分组中的设备
     * @param {string|number} groupId - 分组ID
     * @param {string|number} deviceId - 设备ID
     * @param {Object} deviceData - 设备数据
     * @returns {Promise} API响应
     */
    async updateDeviceInGroup(groupId, deviceId, deviceData) {
        console.log('🔍 [GroupManager] 更新分组设备', { groupId, deviceId, deviceData })
        try {
            const response = await axios.put(`${this.baseUrl}/${groupId}/devices/${deviceId}`, deviceData)
            console.log('✅ [GroupManager] 更新分组设备成功', { groupId, deviceId, deviceData, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 更新分组设备失败:', error)
            throw error
        }
    }

    /**
     * 从分组中删除设备
     * @param {string|number} groupId - 分组ID
     * @param {string|number} deviceId - 设备ID
     * @returns {Promise} API响应
     */
    async deleteDeviceFromGroup(groupId, deviceId) {
        console.log('🔍 [GroupManager] 从分组删除设备', { groupId, deviceId })
        try {
            const response = await axios.delete(`${this.baseUrl}/${groupId}/devices/${deviceId}`)
            console.log('✅ [GroupManager] 从分组删除设备成功', { groupId, deviceId, response })
            return response
        } catch (error) {
            console.error('❌ [GroupManager] 从分组删除设备失败:', error)
            throw error
        }
    }

    // ==================== 兼容性方法 ====================//
    // 为了保持与现有代码的兼容性，提供tree子对象
    
    tree = {
        /**
         * 获取分组树
         * @param {Object} params - 查询参数
         * @returns {Promise} API响应
         */
        getTree: (params = {}) => this.getTree(params),

        /**
         * 创建分组
         * @param {Object} data - 分组数据
         * @returns {Promise} API响应
         */
        create: data => this.createGroup(data),

        /**
         * 更新分组
         * @param {string|number} id - 分组ID
         * @param {Object|string} data - 分组数据或分组名称
         * @returns {Promise} API响应
         */
        update: (id, data) => this.updateGroup(id, data),

        /**
         * 删除分组
         * @param {string|number} id - 分组ID
         * @returns {Promise} API响应
         */
        delete: id => this.deleteGroup(id)
    }
}

export default GroupManager
